#include <iostream>
#include <cstring>
using namespace std;

namespace abl{
//String类模拟实现
class String
{
public:
    typedef char* iterator;
    typedef const char* const_iterator;
public:
//默认成员函数
    String(const char* str = "")
    {
       _size=strlen(str);
       _capacity=_size;
       _str=new char[_capacity+1];//多申请一个空间，用于存放'\0'
       strcpy(_str,str);//将str复制到_str中,直到遇到'\0'为止（包括'\0'）
    }
    ~String()
    {
        delete[] _str;
        _str=nullptr;
        _size=0;
        _capacity=0;
    }
    //拷贝构造-现代写法
    String(const String& str)
    {
        String tmp(str._str);//调用构造函数，用str._str初始化tmp
        ::swap(*this,tmp);//交换*this和tmp
    }
    //赋值重载-传统写法
    // String& operator=(const String& str)
    // {
    //     if(this!=&str)//判断是否为自赋值；注意这里比较的是指针，而不是String对象，所以才能用!=来比较
    //     {
    //         delete[] _str;//先删除旧空间
    //         _str=new char[_capacity+1]();//多申请一个空间，用于存放'\0'
    //         strcpy(_str,str._str);//将str._str复制到_str中,直到遇到'\0'为止（包括'\0'）
    //         _size=str._size;
    //         _capacity=str._capacity;
    //     }
    //     return *this;
    // }
    //赋值重载-现代写法
    String& operator=(const String& str)
    {
        if(this!=&str)//判断是否为自赋值
        {
            String tmp(str);//调用拷贝构造函数，用str初始化tmp
            ::swap(*this,tmp);//交换*this和tmp
        }
        return *this;
    }

//迭代器相关函数
    iterator begin()
    {
        return _str;//返回_str的第一个位置地址
    }
    iterator end()
    {
        return _str+_size;//返回_str的最后一个位置的下一个位置地址
    }
    const_iterator begin() const
    {
        return _str;//返回_str的第一个位置地址
    }
    const_iterator end() const
    {
        return _str+_size;//返回_str的最后一个位置的下一个位置地址
    }

//容量相关函数
    size_t size() const
    {
        return _size;
    }
    size_t capacity() const
    {
        return _capacity;
    }
    void reserve(size_t n)
    {
        //1、若 n>capacity()，则重新分配空间，大小为n
        //2、若 n<=capacity()，则不重新分配空间
        if(n>_capacity)
        {
            char* tmp=new char[n+1]();//多申请一个空间，用于存放'\0'
            strncpy(tmp,_str,_size+1);//为了防止遇到str=“hello world\0\0\0”的情况
            delete[] _str;//删除旧空间
            _str=tmp;
            _capacity=n;
        }
    }
    void resize(size_t n,char ch='\0')
    {
        //若 n>capacity()，则重新分配空间，大小为n
        //1、若 n>size()，则用字符 '\0' 填充到 size() 到 n 之间的字符
        //2、若 n<=size()，则将 size()+n 到末尾的字符，拷贝到 size() 位置
        if(n>_size)
        {
            if(n>_capacity)
            {
                reserve(n);
            }
            for(int i=_size;i<n;i++)
            {
                _str[i]=ch;
            }
            _size=n;
        }
        else
        {
            _size=n;
            _str[_size]='\0';
        }
    }
    bool empty() const
    {
        //return strcmp(_str,"")==0;//字符串不能直接比较大小
        return _size==0;
    }

//修改字符串相关函数
    void push_back(char ch)
    {
        
    }

    char& operator[](size_t i)
    {
        return _str[i];
    }
    const char& operator[](size_t i) const
    {
        return _str[i];
    }

    friend ostream& operator<<(ostream& os, const String& str);
    friend istream& operator>>(istream& is, String& str);

private:
    char* _str;
    size_t _size;
    size_t _capacity;
    static const size_t npos = -1;
    // npos表示字符串结束的位置(在find时，若未找到，返回npos)
    //（在erase时，len若未指定，则删除从pos开始到末尾的字符）
    //（在insert和replace时，若len未指定，则插入或替换从pos开始到末尾的字符）
};

//必须放在类外，不能作为成员函数（因为成员函数第一个参数默认为this指针）
ostream& operator<<(ostream& os,const String& str)
{
    for(int i=0;i<str.size();i++)
    {
        os<<str[i];
    }
    return os;
}
istream& operator>>(istream& is,String& str)
{
    // str.clear()
    // char c=is.get();//读取一个字符
    // while(c!='' || c!='\0')
    // {
    //     str+=c;
    //     is.get();
    // }
    char buff[1024];
    is>>buff;
    delete[] str._str;
    str._str=new char[strlen(buff)+1];
    strcpy(str._str,buff);
    str._size=strlen(buff);
    str._capacity=str._size;
    return is;
}

};




int main()
{
    abl::String s1;
    cin>>s1;
    cout<<s1<<endl;
    return 0;
}




















//int main()
//{
//	string s1;
//	string s2("����");
//	string s3("what happend");
//	string s4(s3);
//	string s5(20, '!');
//	cout << s1 << endl;
//	cout << s2 << endl;
//	cout << s3 << endl;
//	cout << s4 << endl;
//	cout << s5 << endl;
//	string s6(s3, 5, 6);
//	cout << s6 << endl;
//	cout << (s2 == s3 )<< endl;//�����������ȡ�����ȼ��Ƚϸߣ����Ҫ��������
//	cout << (s2 != s3) << endl;
//	s2.append("hello");
//	s5.append("ksjdkjailhiowo");
//	cout << s5<<endl;
//	cout << s2;
//	return 0;
//}
// 
// 
//
//#include <stdio.h>
//#include <stdbool.h>
//
//bool isValveOn(unsigned char v, int iNumber)
//{
//    return v&(0x01<<iNumber);
//}
//
//int main()
//{
//    unsigned char v = 0x45;
//    for (int i = 0; i < 8; i++)
//        printf("Valve %d: %s\n", i, isValveOn(v,i)?"On":"Off");
//    return 0;
//}



//#include <stdio.h>
//
//void printBinary32(unsigned int v)
//{
//    for (int i = 31; i >= 0; i--)
//    {
//        if (v & (0x01 << i))
//        {
//            printf("1");
//        }
//        else
//        {
//            printf("0");
//        }
//    }
//}
//
//int main()
//{
//    unsigned int i = 0;
//    scanf_s("%d", &i);
//    printBinary32(i);
//    return 0;
//}



